package org.Yiran.timetale_re.block.crystal;

import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.BlockGetter;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.properties.BlockStateProperties;
import net.minecraft.world.level.block.state.properties.IntegerProperty;
import org.Yiran.timetale_re.block.crystal.base.CrystalBaseBlock;
import org.Yiran.timetale_re.item.ItemsRegister;
import org.jetbrains.annotations.NotNull;

/**
 * 能晶簇方块
 * <p>
 * 这个类实现了能晶簇方块，继承自CrystalBaseBlock类。
 * 能晶簇是一种特殊的水晶簇，具有独特的属性和掉落物。
 * 能晶簇可以在岩浆旁边或附着在岩浆岩表面时生长。
 * </p>
 */
public class EnergyCrystalClusterBlock extends CrystalBaseBlock {

    // 等级属性，定义能晶簇的强度等级（1-4级）
    public static final IntegerProperty LEVEL = IntegerProperty.create("level", 1, 4);

    // 水晶等级
    private final int level;

    public EnergyCrystalClusterBlock() {
        this(1);
    }
    
    /**
     * 默认构造函数
     * 使用指定等级创建能晶簇方块
     */
    public EnergyCrystalClusterBlock(int level) {
        super();
        this.level = level;

        // 覆盖默认状态中的等级值
        this.registerDefaultState(this.stateDefinition.any()
                .setValue(FACING, Direction.UP)
                .setValue(LEVEL, level)
                .setValue(BlockStateProperties.WATERLOGGED, false));
    }

    @Override
    public IntegerProperty getLevelProperty() {
        // 使用能晶簇的等级属性
        return LEVEL;
    }

    @Override
    public Item getDropItem() {
        return ItemsRegister.ENERGY_GEM.get();
    }

    @Override
    public @NotNull ItemStack getCloneItemStack(@NotNull BlockGetter level, @NotNull BlockPos pos, @NotNull BlockState state) {
        return new ItemStack(ItemsRegister.ENERGY_GEM.get());
    }
    
    /**
     * 检查能晶簇是否可以生长
     * 
     * @param state 方块状态
     * @param level 世界对象
     * @param pos 方块位置
     * @return 是否可以生长
     */
    @Override
    protected boolean canGrow(BlockState state, net.minecraft.server.level.ServerLevel level, BlockPos pos) {
        // 检查基础光照条件
        if (!hasSufficientLight(level, pos)) {
            return false;
        }
        
        // 检查是否在合适的基座上
        return isOnSuitableBase(level, pos);
    }
    
    /**
     * 重写生长方法，根据环境条件调整生长速度
     * 
     * @param state 方块状态
     * @param level 世界
     * @param pos 位置
     */
    @Override
    protected void grow(BlockState state, net.minecraft.server.level.ServerLevel level, BlockPos pos) {
        // 计算生长概率倍数
        int growthMultiplier = calculateGrowthMultiplier(level, pos);
        
        // 获取当前等级和最大等级
        IntegerProperty levelProperty = getLevelProperty();
        int currentLevel = state.getValue(levelProperty);
        int maxLevel = getMaxGrowthLevel();
        
        // 根据倍数决定是否生长
        if (shouldGrow(level, growthMultiplier) && currentLevel < maxLevel) {
            level.setBlock(pos, state.setValue(levelProperty, currentLevel + 1), 2);
        }
    }
    
    /**
     * 检查指定位置是否有足够的光照
     * 
     * @param level 世界对象
     * @param pos 检查位置
     * @return 是否有足够光照
     */
    private boolean hasSufficientLight(net.minecraft.server.level.ServerLevel level, BlockPos pos) {
        int lightLevel = level.getMaxLocalRawBrightness(pos);
        return lightLevel >= 8;
    }
    
    /**
     * 检查能晶簇是否在合适的基座上
     * 
     * @param level 世界对象
     * @param pos 方块位置
     * @return 是否在合适的基座上
     */
    private boolean isOnSuitableBase(net.minecraft.server.level.ServerLevel level, BlockPos pos) {
        // 检查是否在岩浆块上
        BlockPos belowPos = pos.below();
        BlockState belowState = level.getBlockState(belowPos);
        boolean onMagma = belowState.is(Blocks.MAGMA_BLOCK);
        
        // 检查周围是否有岩浆
        boolean nearLava = isNearLava(level, pos);
        
        // 如果在岩浆块上或者附近有岩浆，则可以生长
        return onMagma || nearLava;
    }
    
    /**
     * 检查指定位置周围3x3x3范围内是否有岩浆
     * 为了提高性能，优先检测直接相邻的方块，然后才检测更远的方块
     * 
     * @param level 世界对象
     * @param pos 检查位置
     * @return 是否附近有岩浆
     */
    private boolean isNearLava(net.minecraft.server.level.ServerLevel level, BlockPos pos) {
        // 先检查直接相邻的方块（6个方向）
        for (Direction direction : Direction.values()) {
            BlockPos neighborPos = pos.relative(direction);
            BlockState neighborState = level.getBlockState(neighborPos);
            if (neighborState.is(Blocks.LAVA)) {
                return true;
            }
        }
        
        // 再检查对角线方向的方块（性能优化：只在必要时检查）
        // 检查同一水平面的对角线
        BlockPos[] diagonalOffsets = {
            new BlockPos(1, 0, 1), new BlockPos(1, 0, -1),
            new BlockPos(-1, 0, 1), new BlockPos(-1, 0, -1),
            // 检查垂直方向的对角线
            new BlockPos(1, 1, 0), new BlockPos(-1, 1, 0),
            new BlockPos(0, 1, 1), new BlockPos(0, 1, -1),
            new BlockPos(1, -1, 0), new BlockPos(-1, -1, 0),
            new BlockPos(0, -1, 1), new BlockPos(0, -1, -1),
            // 检查三维对角线
            new BlockPos(1, 1, 1), new BlockPos(1, 1, -1),
            new BlockPos(-1, 1, 1), new BlockPos(-1, 1, -1),
            new BlockPos(1, -1, 1), new BlockPos(1, -1, -1),
            new BlockPos(-1, -1, 1), new BlockPos(-1, -1, -1)
        };
        
        for (BlockPos offset : diagonalOffsets) {
            BlockPos checkPos = pos.offset(offset);
            BlockState blockState = level.getBlockState(checkPos);
            if (blockState.is(Blocks.LAVA)) {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * 计算生长概率倍数
     * 
     * @param level 世界对象
     * @param pos 方块位置
     * @return 生长概率倍数
     */
    private int calculateGrowthMultiplier(net.minecraft.server.level.ServerLevel level, BlockPos pos) {
        // 基础生长倍数
        int growthMultiplier = 1;
        
        // 检查是否在岩浆块上
        if (isOnMagmaBlock(level, pos)) {
            growthMultiplier *= 2; // 在岩浆块上生长速度翻倍
        }
        
        // 检查周围是否有岩浆
        if (isNearLava(level, pos)) {
            growthMultiplier *= 2; // 附近有岩浆生长速度翻倍
        }
        
        // 根据光照等级调整生长速度
        int lightLevel = level.getMaxLocalRawBrightness(pos);
        // 光照等级越高，生长速度越快，最高4倍
        int lightMultiplier = Math.max(1, lightLevel / 4);
        
        // 综合生长速度倍数
        return growthMultiplier * lightMultiplier;
    }
    
    /**
     * 检查能晶簇是否放置在岩浆块上
     * 
     * @param level 世界对象
     * @param pos 方块位置
     * @return 是否在岩浆块上
     */
    private boolean isOnMagmaBlock(net.minecraft.server.level.ServerLevel level, BlockPos pos) {
        BlockPos belowPos = pos.below();
        BlockState belowState = level.getBlockState(belowPos);
        return belowState.is(Blocks.MAGMA_BLOCK);
    }
    
    /**
     * 根据倍数判断是否应该生长
     * 
     * @param level 世界对象
     * @param multiplier 生长倍数
     * @return 是否应该生长
     */
    private boolean shouldGrow(net.minecraft.server.level.ServerLevel level, int multiplier) {
        return level.getRandom().nextInt(multiplier) == 0;
    }

    // ==================== 访问器方法 ====================

    public int getLevel() {
        return level;
    }
}